/**
 * 菜单路径到组件的映射表
 * 根据菜单的 menu_path 映射到对应的 Vue 组件
 */
const menuPathToComponent = {
  // 学生管理
  '/homepage/student': () => import('@/views/StudentManage'),
  
  // 教师管理
  '/homepage/teacher': () => import('@/views/TeacherManage'),
  
  // 教学管理
  '/homepage/teaching': () => import('@/views/TeachingManage'),
  
  // 学校管理
  '/homepage/schoolManage': () => import('@/views/SchoolManage'),
  
  // 查看学校详情
  '/homepage/schoolManage/:schoolId': () => import('@/views/ViewSchool'),
  '/homepage/viewSchool/:schoolId': () => import('@/views/ViewSchool'),
  
  // 校务管理
  '/homepage/rightsManage': () => import('@/views/RightsManage'),
  
  // 校务管理 - 成员列表
  '/homepage/rightsManage/memberList': () => import('@/views/rightsManage/MemberList'),
  
  // 系统管理
  '/homepage/systemManage': () => import('@/views/SystemManage'),
  
  // 系统管理 - 系统用户
  '/homepage/systemManage/systemUserList': () => import('@/views/systemManage/SystemUserList'),
  
  // 系统管理 - 菜单列表
  '/homepage/systemManage/menuList': () => import('@/views/systemManage/MenuList'),
  
  // 系统管理 - 角色列表
  '/homepage/systemManage/roleList': () => import('@/views/systemManage/RoleList'),
  
  // 学校管理 - 学生组件
  '/homepage/schoolManage/:schoolId/student': () => import('@/components/schoolmanage/studentComp.vue'),
  
  // 学校管理 - 教师组件
  '/homepage/schoolManage/:schoolId/teacher': () => import('@/components/schoolmanage/teacherComp.vue'),
  
  // 学校管理 - 班级组件
  '/homepage/schoolManage/:schoolId/class': () => import('@/components/schoolmanage/classComp.vue'),
};

/**
 * 根据菜单路径获取组件
 * @param {string} menuPath - 菜单路径
 * @returns {Function|null} - 组件加载函数，如果找不到则返回 null
 */
export function getComponentByMenuPath(menuPath) {
  if (!menuPath) return null;
  
  // 直接匹配
  if (menuPathToComponent[menuPath]) {
    return menuPathToComponent[menuPath];
  }
  
  // 处理动态路由参数，如 /homepage/schoolManage/123/student
  // 匹配模式：/homepage/schoolManage/:schoolId/student
  const dynamicPatterns = Object.keys(menuPathToComponent).filter(key => key.includes(':'));
  
  for (const pattern of dynamicPatterns) {
    const regex = new RegExp('^' + pattern.replace(/:[^/]+/g, '[^/]+') + '$');
    if (regex.test(menuPath)) {
      return menuPathToComponent[pattern];
    }
  }
  
  // 如果找不到，尝试使用默认组件（404 或空组件）
  console.warn(`未找到菜单路径对应的组件: ${menuPath}`);
  return null;
}

/**
 * 根据菜单数据生成路由配置
 * @param {Array} menuList - 菜单列表
 * @param {string} parentPath - 父路径（用于嵌套路由）
 * @returns {Array} - 路由配置数组
 */
export function generateRoutesFromMenus(menuList, parentPath = '/homepage') {
  if (!menuList || !Array.isArray(menuList)) {
    console.warn('generateRoutesFromMenus: menuList 为空或不是数组', menuList);
    return [];
  }
  
  console.log('generateRoutesFromMenus: 开始处理菜单列表，数量:', menuList.length, 'parentPath:', parentPath);
  
  const routes = [];
  
  menuList.forEach((menu, index) => {
    console.log(`处理菜单 ${index + 1}/${menuList.length}:`, {
      menu_name: menu.menu_name,
      menu_path: menu.menu_path,
      menu_type: menu.menu_type,
      parent_id: menu.parent_id,
      children_count: menu.children?.length || 0
    });
    
    // 只处理菜单项类型（menu_type === 1），忽略功能按钮（menu_type === 2）
    if (menu.menu_type === 2) {
      console.log(`跳过功能按钮: ${menu.menu_name}`);
      return;
    }
    
    const menuPath = menu.menu_path || '';
    if (!menuPath) {
      console.warn(`菜单 "${menu.menu_name}" 没有 menu_path，跳过`);
      return;
    }
    
    // 确保路径是绝对路径
    let fullPath = menuPath;
    if (!menuPath.startsWith('/')) {
      fullPath = parentPath === '/homepage' ? `/homepage/${menuPath}` : `${parentPath}/${menuPath}`;
    }
    
    console.log(`计算完整路径: menuPath=${menuPath}, parentPath=${parentPath}, fullPath=${fullPath}`);
    
    // 获取对应的组件
    const component = getComponentByMenuPath(fullPath);
    
    if (!component) {
      console.warn(`菜单 "${menu.menu_name}" (路径: ${fullPath}) 未找到对应的组件，跳过路由添加`);
      return;
    }
    
    console.log(`找到组件: ${menu.menu_name} -> ${fullPath}`);
    
    // 生成路由名称（优先使用路径，确保与组件中的 routerName 匹配）
    // 例如：/homepage/systemManage/systemUserList -> systemUserList
    let routeName = '';
    if (fullPath) {
      // 从路径中提取最后一段作为路由名称
      const pathParts = fullPath.split('/').filter(part => part && part !== 'homepage');
      if (pathParts.length > 0) {
        // 使用路径的最后一段，并转换为驼峰命名
        const lastPart = pathParts[pathParts.length - 1];
        // 如果路径是 /homepage/systemManage/systemUserList，则路由名称为 systemUserList
        routeName = lastPart;
      }
    }
    
    // 如果从路径无法生成路由名称，则使用菜单名称
    if (!routeName && menu.menu_name) {
      routeName = menu.menu_name.replace(/\s+/g, '');
    }
    
    // 如果还是无法生成，使用路径
    if (!routeName) {
      routeName = fullPath.replace(/\//g, '').replace(/:/g, '');
    }
    
    // 生成子路由路径（相对于父路由）
    // 如果 parentPath 是 /homepage/rightsManage，fullPath 是 /homepage/rightsManage/memberList
    // 则子路由 path 应该是 memberList（相对于父路由 rightsManage）
    let routePath = '';
    if (parentPath === '/homepage') {
      // 顶级菜单：/homepage/systemManage -> systemManage
      routePath = fullPath.replace('/homepage/', '');
    } else {
      // 子菜单：需要计算相对于父路径的路径
      // 例如：parentPath = /homepage/rightsManage, fullPath = /homepage/rightsManage/memberList
      // routePath 应该是 memberList
      if (fullPath.startsWith(parentPath + '/')) {
        routePath = fullPath.substring(parentPath.length + 1);
      } else {
        // 如果路径不匹配，使用完整路径（移除 /homepage）
        routePath = fullPath.replace('/homepage/', '');
      }
    }
    
    // 移除前导斜杠，确保是相对路径
    if (routePath.startsWith('/')) {
      routePath = routePath.substring(1);
    }
    
    // 如果路径为空，使用默认路径
    if (!routePath) {
      routePath = '/';
    }
    
    console.log(`生成路由: name=${routeName}, path=${routePath}, fullPath=${fullPath}`);
    
    const route = {
      path: routePath,
      name: routeName,
      component: component,
      meta: {
        menuId: menu.id,
        menuName: menu.menu_name,
        menuIcon: menu.menu_icon,
      }
    };
    
    // 如果有子菜单，递归处理
    if (menu.children && Array.isArray(menu.children) && menu.children.length > 0) {
      console.log(`菜单 "${menu.menu_name}" 有 ${menu.children.length} 个子菜单，开始递归处理`);
      route.children = generateRoutesFromMenus(menu.children, fullPath);
      console.log(`菜单 "${menu.menu_name}" 递归处理完成，生成了 ${route.children.length} 个子路由`);
      
      // 如果有子路由，设置默认重定向到第一个子路由
      if (route.children.length > 0) {
        // 使用路由名称重定向，更可靠
        const firstChildName = route.children[0].name;
        if (firstChildName) {
          route.redirect = { name: firstChildName };
          console.log(`设置重定向: ${menu.menu_name} -> ${firstChildName}`);
        } else {
          // 如果没有名称，使用路径重定向（相对路径）
          const firstChildPath = route.children[0].path;
          route.redirect = firstChildPath;
          console.log(`设置重定向: ${menu.menu_name} -> ${firstChildPath}`);
        }
      } else {
        console.warn(`菜单 "${menu.menu_name}" 有子菜单但未生成任何子路由`);
      }
    } else {
      console.log(`菜单 "${menu.menu_name}" 没有子菜单`);
    }
    
    routes.push(route);
  });
  
  console.log(`generateRoutesFromMenus: 处理完成，生成了 ${routes.length} 个路由`);
  return routes;
}

export default {
  menuPathToComponent,
  getComponentByMenuPath,
  generateRoutesFromMenus,
};

